71 research outputs found
Achieving Dilution without Knowledge of Coordinates in the SINR Model
Considerable literature has been developed for various fundamental
distributed problems in the SINR (Signal-to-Interference-plus-Noise-Ratio)
model for radio transmission. A setting typically studied is when all nodes
transmit a signal of the same strength, and each device only has access to
knowledge about the total number of nodes in the network , the range from
which each node's label is taken , and the label of the device
itself. In addition, an assumption is made that each node also knows its
coordinates in the Euclidean plane. In this paper, we create a technique which
allows algorithm designers to remove that last assumption. The assumption about
the unavailability of the knowledge of the physical coordinates of the nodes
truly captures the `ad-hoc' nature of wireless networks.
Previous work in this area uses a flavor of a technique called dilution, in
which nodes transmit in a (predetermined) round-robin fashion, and are able to
reach all their neighbors. However, without knowing the physical coordinates,
it's not possible to know the coordinates of their containing (pivotal) grid
box and seemingly not possible to use dilution (to coordinate their
transmissions). We propose a new technique to achieve dilution without using
the knowledge of physical coordinates. This technique exploits the
understanding that the transmitting nodes lie in 2-D space, segmented by an
appropriate pivotal grid, without explicitly referring to the actual physical
coordinates of these nodes. Using this technique, it is possible for every weak
device to successfully transmit its message to all of its neighbors in
rounds, as long as the density of transmitting nodes in any
physical grid box is bounded by a known constant. This technique, we feel, is
an important generic tool for devising practical protocols when physical
coordinates of the nodes are not known.Comment: 10 page
Dispersion, Capacitated Nodes, and the Power of a Trusted Shepherd
In this paper, we look at and expand the problems of dispersion and Byzantine
dispersion of mobile robots on a graph, introduced by Augustine and
Moses~Jr.~[ICDCN~2018] and by Molla, Mondal, and Moses~Jr.~[ALGOSENSORS~2020],
respectively, to graphs where nodes have variable capacities. We use the idea
of a single shepherd, a more powerful robot that will never act in a Byzantine
manner, to achieve fast Byzantine dispersion, even when other robots may be
strong Byzantine in nature. We also show the benefit of a shepherd for
dispersion on capacitated graphs when no Byzantine robots are present
Distributed MST Computation in the Sleeping Model: Awake-Optimal Algorithms and Lower Bounds
We study the distributed minimum spanning tree (MST) problem, a fundamental
problem in distributed computing. It is well-known that distributed MST can be
solved in rounds in the standard CONGEST model (where
is the network size and is the network diameter) and this is
essentially the best possible round complexity (up to logarithmic factors).
However, in resource-constrained networks such as ad hoc wireless and sensor
networks, nodes spending so much time can lead to significant spending of
resources such as energy.
Motivated by the above consideration, we study distributed algorithms for MST
under the \emph{sleeping model} [Chatterjee et al., PODC 2020], a model for
design and analysis of resource-efficient distributed algorithms. In the
sleeping model, a node can be in one of two modes in any round --
\emph{sleeping} or \emph{awake} (unlike the traditional model where nodes are
always awake). Only the rounds in which a node is \emph{awake} are counted,
while \emph{sleeping} rounds are ignored. A node spends resources only in the
awake rounds and hence the main goal is to minimize the \emph{awake complexity}
of a distributed algorithm, the worst-case number of rounds any node is awake.
We present deterministic and randomized distributed MST algorithms that have
an \emph{optimal} awake complexity of time with a matching lower
bound. We also show that our randomized awake-optimal algorithm has essentially
the best possible round complexity by presenting a lower bound of
on the product of the awake and round complexity of any
distributed algorithm (including randomized) that outputs an MST, where
hides a factor.Comment: 28 pages, 1 table, 5 figures, abstract modified to fit arXiv
constraint
Sleeping is Superefficient: MIS in Exponentially Better Awake Complexity
Maximal Independent Set (MIS) is one of the central and most well-studied
problems in distributed computing. Even after four decades of intensive
research, the best-known (randomized) MIS algorithms take
worst-case rounds on general graphs (where is the number of nodes), while
the best-known lower bound is
rounds. Breaking past
the worst-case bound or showing stronger lower bounds have been
longstanding open problems.
Our main contribution is that we show that MIS can be computed in
(worst-case) awake complexity of rounds that is (essentially)
exponentially better compared to the (traditional) round complexity lower bound
of . Specifically, we
present the following results. (1) We present a randomized distributed (Monte
Carlo) algorithm for MIS that with high probability computes an MIS and has
-rounds awake complexity. This algorithm has (traditional) {\em
round complexity} that is . Our bounds hold in the
model where only (specifically ) bits are allowed to be sent per edge per round. (2) We also show that we
can drastically reduce the round complexity at the cost of a slight increase in
awake complexity by presenting a randomized MIS algorithm with awake complexity and round
complexity in the model.Comment: Abstract shortened to fit arXiv constraint
Fast Deterministic Gathering with Detection on Arbitrary Graphs: The Power of Many Robots
Over the years, much research involving mobile computational entities has been performed. From modeling actual microscopic (and smaller) robots, to modeling software processes on a network, many important problems have been studied in this context. Gathering is one such fundamental problem in this area. The problem of gathering k robots, initially arbitrarily placed on the nodes of an n-node graph, asks that these robots coordinate and communicate in a local manner, as opposed to global, to move around the graph, find each other, and settle down on a single node as fast as possible. A more difficult problem to solve is gathering with detection, where once the robots gather, they must subsequently realize that gathering has occurred and then terminate. In this paper, we propose a deterministic approach to solve gathering with detection for any arbitrary connected graph that is faster than existing deterministic solutions for even just gathering (without the requirement of detection) for arbitrary graphs. In contrast to earlier work on gathering, it leverages the fact that there are more robots present in the system to achieve gathering with detection faster than those previous papers that focused on just gathering. The state of the art solution for deterministic gathering [Ta-Shma and Zwick, TALG, 2014] takes OΛ(n 5 log β) rounds, where β is the smallest label among robots and OΛ hides a polylog factor. We design a deterministic algorithm for gathering with detection with the following trade-offs depending on how many robots are present: (i) when k β₯ βn/2β + 1, the algorithm takes O(n 3 ) rounds, (ii) when k β₯ βn/3β+1, the algorithm takes O(n 4 log n) rounds, and (iii) otherwise, the algorithm takes OΛ(n 5 ) rounds. The algorithm is not required to know k, but only
Time- and Communication-Efficient Overlay Network Construction via Gossip
We focus on the well-studied problem of distributed overlay network
construction. We consider a synchronous gossip-based communication model where
in each round a node can send a message of small size to another node whose
identifier it knows. The network is assumed to be reconfigurable, i.e., a node
can add new connections (edges) to other nodes whose identifier it knows or
drop existing connections. Each node initially has only knowledge of its own
identifier and the identifiers of its neighbors. The overlay construction
problem is, given an arbitrary (connected) graph, to reconfigure it to obtain a
bounded-degree expander graph as efficiently as possible. The overlay
construction problem is relevant to building real-world peer-to-peer network
topologies that have desirable properties such as low diameter, high
conductance, robustness to adversarial deletions, etc.
Our main result is that we show that starting from any arbitrary (connected)
graph on nodes and edges, we can construct an overlay network that
is a constant-degree expander in polylog rounds using only
messages. Our time and message bounds are both essentially optimal (up to
polylogarithmic factors). Our distributed overlay construction protocol is very
lightweight as it uses gossip (each node communicates with only one neighbor in
each round) and also scalable as it uses only messages, which is
sublinear in (even when is moderately dense). To the best of our
knowledge, this is the first result that achieves overlay network construction
in polylog rounds and messages. Our protocol uses graph sketches in
a novel way to construct an expander overlay that is both time and
communication efficient. A consequence of our overlay construction protocol is
that distributed computation can be performed very efficiently in this model.Comment: Slightly shortened abstrac
Distributed MIS in O(log log n) Awake Complexity
Maximal Independent Set (MIS) is one of the fundamental and most well-studied problems in distributed graph algorithms. Even after four decades of intensive research, the best known (randomized) MIS algorithms have O(log n) round complexity on general graphs [Luby, STOC 1986] (where n is the number of nodes), while the best known lower bound is [EQUATION] [Kuhn, Moscibroda, Wattenhofer, JACM 2016]. Breaking past the O(log n) round complexity upper bound or showing stronger lower bounds have been longstanding open problems. Energy is a premium resource in various settings such as battery-powered wireless networks and sensor networks. The bulk of the energy is used by nodes when they are awake, i.e., when they are sending, receiving, and even just listening for messages. On the other hand, when a node is sleeping, it does not perform any communication and thus spends very little energy. Several recent works have addressed the problem of designing energy-efficient distributed algorithms for various fundamental problems. These algorithms operate by minimizing the number of rounds in which any node is awake, also called the (worst-case) awake complexity. An intriguing open question is whether one can design a distributed MIS algorithm that has significantly smaller awake complexity compared to existing algorithms. In particular, the question of obtaining a distributed MIS algorithm with o(log n) awake complexity was left open in [Chatterjee, Gmyr, Pandurangan, PODC 2020]. Our main contribution is to show that MIS can be computed in awake complexity that is exponentially better compared to the best known round complexity of O(log n) and also bypassing its fundamental [EQUATION] round complexity lower bound exponentially. Specifically, we show that MIS can be computed by a randomized distributed (Monte Carlo) algorithm in O(log log n) awake complexity with high probability.1 However, this algorithm has a round complexity that is O(poly(n)). We then show how to drastically improve the round complexity at the cost of a slight increase in awake complexity by presenting a randomized distributed (Monte Carlo) algorithm for MIS that, with high probability computes an MIS in O((log log n) log* n) awake complexity and O((log3 n)(log log n) log* n) round complexity. Our algorithms work in the CONGEST model where messages of size O(log n) bits can be sent per edge per round
Distributed MIS in O(log log n) Awake Complexity
Maximal Independent Set (MIS) is one of the fundamental and most well-studied problems in distributed graph algorithms. Even after four decades of intensive research, the best known (randomized) MIS algorithms have O(log n) round complexity on general graphs [Luby, STOC 1986] (where n is the number of nodes), while the best known lower bound is [EQUATION] [Kuhn, Moscibroda, Wattenhofer, JACM 2016]. Breaking past the O(log n) round complexity upper bound or showing stronger lower bounds have been longstanding open problems.
Energy is a premium resource in various settings such as battery-powered wireless networks and sensor networks. The bulk of the energy is used by nodes when they are awake, i.e., when they are sending, receiving, and even just listening for messages. On the other hand, when a node is sleeping, it does not perform any communication and thus spends very little energy. Several recent works have addressed the problem of designing energy-efficient distributed algorithms for various fundamental problems. These algorithms operate by minimizing the number of rounds in which any node is awake, also called the (worst-case) awake complexity. An intriguing open question is whether one can design a distributed MIS algorithm that has significantly smaller awake complexity compared to existing algorithms. In particular, the question of obtaining a distributed MIS algorithm with o(log n) awake complexity was left open in [Chatterjee, Gmyr, Pandurangan, PODC 2020].
Our main contribution is to show that MIS can be computed in awake complexity that is exponentially better compared to the best known round complexity of O(log n) and also bypassing its fundamental [EQUATION] round complexity lower bound exponentially. Specifically, we show that MIS can be computed by a randomized distributed (Monte Carlo) algorithm in O(log log n) awake complexity with high probability.1 However, this algorithm has a round complexity that is O(poly(n)). We then show how to drastically improve the round complexity at the cost of a slight increase in awake complexity by presenting a randomized distributed (Monte Carlo) algorithm for MIS that, with high probability computes an MIS in O((log log n) log* n) awake complexity and O((log3 n)(log log n) log* n) round complexity. Our algorithms work in the CONGEST model where messages of size O(log n) bits can be sent per edge per round
- β¦